
from interfaz import Interfaz
from constantes import *

class Jugador(object):
	"""Representa a un jugador de TEG."""
	def __init__(self, color, nombre):
		"""Crea un jugador desde un color y un nombre."""
		self.color = color
		self.nombre = nombre
		self.tarjetas = []
		self.canjes = 0

	def atacar(self, tablero):
		"""Le pide al usuario que ingrese un par de paises para
		realizar un ataque. Devuelve None si el jugador no quiere
		atacar y un par (atacante, atacado) en caso contrario."""
		while True:
			Interfaz.setear_titulo('%s ataca. Seleccionar atacante' % self)

			atacante, boton = Interfaz.seleccionar_pais()
			while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(atacante) != self.color or tablero.ejercitos_pais(atacante) == 1):
				atacante, boton = Interfaz.seleccionar_pais()
			if boton != Interfaz.BOTON_IZQUIERDO:
				return None

			Interfaz.setear_titulo('%s ataca. Seleccionar pais atacado por %s' % (self, atacante))

			atacado, boton = Interfaz.seleccionar_pais()
			while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(atacado) == self.color or not tablero.es_limitrofe(atacante, atacado)):
				atacado, boton = Interfaz.seleccionar_pais()
			if boton != Interfaz.BOTON_IZQUIERDO:
				continue

			return (atacante, atacado)

	def agregar_ejercitos(self, tablero, cantidad):
		"""Recibe un tablero y un diccionario con la cantidad de paises
		a poner. Devuelve un diccionario con los paises que el usuario
		selecciono.
		Por ejemplo, si cantidad = {"": 2, "Africa": 3}, eso significa
		que el jugador va a poner 5 ejercitos en sus paises, de los
		cuales 3 tienen que estar obligatoriamente en Africa.
		Un ejemplo de retorno de la funcion podria ser
		{"Zaire": 4, "Italia": 1}."""
		paises_seleccionados = {}
		for continente, cant in cantidad.items():
			if continente == "":
				Interfaz.setear_titulo("%s agrega %d ejercitos. Seleccionar pais donde se desea agregar fichas." %(self, cant))
			else:
				Interfaz.setear_titulo("%s agrega %d ejercitos en %s. Seleccionar pais de %s donde se desea agregar fichas." %(self, cant, continente, continente))
				
			while cant != 0:
				pais, boton = Interfaz.seleccionar_pais()
				if boton == Interfaz.BOTON_IZQUIERDO and tablero.color_pais(pais) == self.color and (continente == "" or continente == tablero.continente_pais(pais)):
					ejercitos = Interfaz.elegir("Ejercitos", "Elija la cantidad de ejercitos que desea agregar en %s" %pais, range(0,cant + 1))
					paises_seleccionados[pais] = ejercitos
					cant -= ejercitos
					tablero.actualizar_interfaz({pais : ejercitos})
				
		return paises_seleccionados
				
	def reagrupar(self, tablero):
		"""Recibe el tablero y le pide al jugador que seleccione todos
		los ejercitos que desea reagrupar. Devuelve una lista de
		reagrupamientos.
		Solo se podran reagrupar ejercitos a paises limitrofes, nunca
		un pais podra quedar vacio.
		Un ejemplo de devolcion de esta funcion puede ser:
		[('Argentina', 'Uruguay', 2), ('Argentina', 'Brasil', 1),
			('Chile', 'Argentina', 1)]
		Esto significa que de Argentina se reagrupan 3 ejercitos, 2 con
		destino a Uruguay y 1 con destino a Brasil. Argentina tiene que
		tener al menos 4 ejercitos. De Chile se pasa uno a Argentina,
		por lo que Chile tiene que tener al menos 1. Todos los paises
		tienen que pertenecer al jugador. Despues de implementado el
		reagrupamiento, Brasil quedara con 1 ejercito mas, Uruguay con
		2 mas, Argentina con 2 menos (salen 3, entra 1) y Chile con 1
		menos."""
		reagrupaciones = []
		while True:
			Interfaz.setear_titulo("%s reagrupa. Seleccionar pais desde donde reagrupar" %self)
	
			ejercitos_agregados = 0
					
			pais_origen, boton = Interfaz.seleccionar_pais()
			ejer_reag_origen = self.cantidad_de_ejercitos_reagrupados(pais_origen, reagrupaciones)
			while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(pais_origen) != self.color or (tablero.ejercitos_pais(pais_origen) + ejer_reag_origen) < 2):
				pais_origen, boton = Interfaz.seleccionar_pais()
				ejer_reag_origen = self.cantidad_de_ejercitos_reagrupados(pais_origen, reagrupaciones)
			if boton != Interfaz.BOTON_IZQUIERDO:
				return reagrupaciones
			
			Interfaz.setear_titulo("%s reagrupa. Seleccionar pais a donde desea reagrupar desde %s" %(self, pais_origen))
			
			pais_destino, boton = Interfaz.seleccionar_pais()
			while boton == Interfaz.BOTON_IZQUIERDO and (tablero.color_pais(pais_destino) != self.color or not tablero.es_limitrofe(pais_origen, pais_destino)):
				pais_detino, boton = Interfaz.seleccionar_pais()
			if boton != Interfaz.BOTON_IZQUIERDO:
				continue
			ejer_reag_destino = self.cantidad_de_ejercitos_reagrupados(pais_destino, reagrupaciones)
			
			cantidad = Interfaz.elegir("Ejercitos", "Elija cuantos ejercitos desea reagrupar de %s a %s." %(pais_origen, pais_destino), range(0, tablero.ejercitos_pais(pais_origen) + ejer_reag_origen))
			reagrupaciones.append((pais_origen, pais_destino, cantidad))
			tablero.actualizar_interfaz({pais_origen : -cantidad + ejer_reag_origen, pais_destino : cantidad + ejer_reag_destino})
			
	def cantidad_de_ejercitos_reagrupados(self, pais, reagrupaciones):
		"""	Recive un pais y las reagrupaciones que ya a hecho el jugador.
			Devuelve la cantidad de ejercitos que se han reagrupados desde
			o a ese pais en esta ronda."""
		ejercitos_movidos = 0
		for reagrupacion in reagrupaciones:
			if pais == reagrupacion[0]:
				ejercitos_movidos -= reagrupacion[2]
			if pais == reagrupacion[1]:
				ejercitos_movidos += reagrupacion[2]
		return ejercitos_movidos
			
	def __str__(self):
		"""Representacion de un jugador."""
		return '%s (%s)' % (self.nombre, NOMBRE_COLORES[self.color])
